unist-util-remove

What is unist-util-remove?

The unist-util-remove package is a utility for removing nodes from a Unist syntax tree. It allows you to filter out nodes based on specific criteria, making it useful for manipulating abstract syntax trees (ASTs) in various text processing tasks.

What are unist-util-remove's main functionalities?

Remove nodes by type

This feature allows you to remove all nodes of a specific type from the tree. In this example, all 'paragraph' nodes are removed from the tree.

const remove = require('unist-util-remove');
const tree = { type: 'root', children: [ { type: 'paragraph', children: [ { type: 'text', value: 'Hello' } ] }, { type: 'paragraph', children: [ { type: 'text', value: 'World' } ] } ] };
remove(tree, 'paragraph');
console.log(tree);

Remove nodes by test function

This feature allows you to remove nodes based on a test function. In this example, only the 'paragraph' node containing the text 'World' is removed.

const remove = require('unist-util-remove');
const tree = { type: 'root', children: [ { type: 'paragraph', children: [ { type: 'text', value: 'Hello' } ] }, { type: 'paragraph', children: [ { type: 'text', value: 'World' } ] } ] };
remove(tree, node => node.type === 'paragraph' && node.children[0].value === 'World');
console.log(tree);

Remove nodes by index

This feature allows you to remove nodes by their index in the parent node's children array. In this example, the second 'paragraph' node (index 1) is removed.

const remove = require('unist-util-remove');
const tree = { type: 'root', children: [ { type: 'paragraph', children: [ { type: 'text', value: 'Hello' } ] }, { type: 'paragraph', children: [ { type: 'text', value: 'World' } ] } ] };
remove(tree, { type: 'paragraph' }, 1);
console.log(tree);

Other packages similar to unist-util-remove

unist-util-filter

The unist-util-filter package allows you to filter nodes in a Unist tree based on a test function. It is similar to unist-util-remove but instead of removing nodes, it creates a new tree with only the nodes that pass the test.

unist-util-visit

The unist-util-visit package is used to recursively walk through a Unist tree and perform actions on nodes that match a specific type or test function. While it doesn't remove nodes, it can be used in conjunction with other utilities to manipulate the tree.

unist-util-map

The unist-util-map package allows you to transform nodes in a Unist tree by applying a function to each node. It is useful for modifying the tree structure or node values, but it does not directly remove nodes.

README

unist-util-remove

unist utility to remove all nodes that pass a test from the tree.

Contents

• What is this?
• When should I use this?
• Install
• Use
• API
  • remove(tree[, options], test)
  • Options
• Types
• Compatibility
• Related
• Contribute
• License

What is this?

This is a small utility that helps you clean a tree by removing some stuff.

When should I use this?

You can use this utility to remove things from a tree. This utility is very similar to unist-util-filter, which creates a new tree. Modifying a tree like this utility unist-util-remove does is much faster on larger documents though.

You can also walk the tree with unist-util-visit to remove nodes. To create trees, use unist-builder.

Install

This package is ESM only. In Node.js (version 14.14+ and 16.0+), install with npm:

npm install unist-util-remove

In Deno with esm.sh:

import {remove} from 'https://esm.sh/unist-util-remove@3'

In browsers with esm.sh:

<script type="module">
  import {remove} from 'https://esm.sh/unist-util-remove@3?bundle'
</script>

Use

import {u} from 'unist-builder'
import {remove} from 'unist-util-remove'

const tree = u('root', [
  u('leaf', '1'),
  u('parent', [
    u('leaf', '2'),
    u('parent', [u('leaf', '3'), u('other', '4')]),
    u('parent', [u('leaf', '5')])
  ]),
  u('leaf', '6')
])

// Remove all nodes of type `leaf`.
remove(tree, 'leaf')

console.dir(tree, {depth: null})

Yields:

{
  type: 'root',
  children: [
    {
      type: 'parent',
      children: [{type: 'parent', children: [{type: 'other', value: '4'}]}]
    }
  ]
}

👉 Note: the parent of leaf 5 is also removed, options.cascade can change that.

API

This package exports the identifier remove. There is no default export.

remove(tree[, options], test)

Change the given tree by removing all nodes that pass test.

The tree is walked in preorder (NLR), visiting the node itself, then its head, etc.

Parameters

• tree (Node) — tree to change
• options (Options, optional) — configuration
• test (Test, optional) — unist-util-is compatible test

Returns

A changed given tree, without nodes that pass test.

null is returned if tree itself didn’t pass the test or is cascaded away.

Options

Configuration (TypeScript type).

Fields

• cascade (boolean, default: true) — whether to drop parent nodes if they had children, but all their children were filtered out

Types

This package is fully typed with TypeScript. It exports the additional type Options.

Compatibility

Projects maintained by the unified collective are compatible with all maintained versions of Node.js. As of now, that is Node.js 12.20+, 14.14+, 16.0+, and 18.0+. Our projects sometimes work with older versions, but this is not guaranteed.

Related

• unist-util-filter — create a new tree with all nodes that pass the given function
• unist-util-flatmap — create a new tree by expanding a node into many
• unist-util-map — create a new tree by mapping nodes
• unist-util-select — select nodes with CSS-like selectors
• unist-util-visit — walk the tree
• unist-builder — create trees

Contribute

See contributing.md in syntax-tree/.github for ways to get started. See support.md for ways to get help.

This project has a Code of Conduct. By interacting with this repository, organisation, or community you agree to abide by its terms.

License

MIT © Eugene Sharygin